home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / etc / RCS / swapBuffer.c,v < prev    next >
Text File  |  1989-07-01  |  37KB  |  1,431 lines
  1. head     1.9;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.9
  10. date     89.07.01.02.35.23;  author rab;  state Exp;
  11. branches ;
  12. next     1.8;
  13.  
  14. 1.8
  15. date     89.05.31.14.49.44;  author jhh;  state Exp;
  16. branches ;
  17. next     1.7;
  18.  
  19. 1.7
  20. date     89.02.27.17.50.00;  author mgbaker;  state Exp;
  21. branches ;
  22. next     1.6;
  23.  
  24. 1.6
  25. date     88.09.16.12.41.59;  author mlgray;  state Exp;
  26. branches ;
  27. next     1.5;
  28.  
  29. 1.5
  30. date     88.09.14.16.46.25;  author mlgray;  state Exp;
  31. branches ;
  32. next     1.4;
  33.  
  34. 1.4
  35. date     88.09.14.12.22.20;  author mlgray;  state Exp;
  36. branches ;
  37. next     1.3;
  38.  
  39. 1.3
  40. date     88.09.13.19.37.15;  author mlgray;  state Exp;
  41. branches ;
  42. next     1.2;
  43.  
  44. 1.2
  45. date     88.09.13.12.51.12;  author mlgray;  state Exp;
  46. branches ;
  47. next     1.1;
  48.  
  49. 1.1
  50. date     88.09.13.11.17.53;  author brent;  state Exp;
  51. branches ;
  52. next     ;
  53.  
  54.  
  55. desc
  56. @Byte swapping utility procedures
  57. @
  58.  
  59.  
  60. 1.9
  61. log
  62. @*** empty log message ***
  63. @
  64. text
  65. @/*
  66.  * swapBuffer.c --
  67.  *
  68.  *    Byte-swapping routines.  Note that this may be clumsy and slow
  69.  *    at first since data is copied twice in some instances.
  70.  *
  71.  *    Current bad assumption: I don't check whether I'm running off the
  72.  *    end of a buffer during a particular copy (a byte copy, a half-word
  73.  *    copy, word copy).  Fix this by checking right before the copy?.
  74.  *
  75.  *
  76.  * Copyright 1988 Regents of the University of California
  77.  * Permission to use, copy, modify, and distribute this
  78.  * software and its documentation for any purpose and without
  79.  * fee is hereby granted, provided that the above copyright
  80.  * notice appear in all copies.  The University of California
  81.  * makes no representations about the suitability of this
  82.  * software for any purpose.  It is provided "as is" without
  83.  * express or implied warranty.
  84.  */
  85.  
  86. #ifndef lint
  87. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/swapBuffer.c,v 1.8 89/05/31 14:49:44 jhh Exp Locker: rab $ SPRITE (Berkeley)";
  88. #endif not lint
  89.  
  90.  
  91. #include "sprite.h"
  92. #include "ctype.h"
  93. #include "string.h"
  94. #include "swapBuffer.h"
  95.  
  96. /*
  97.  * On nasty errors we want to panic in a user process, but not let a
  98.  * user process panic in the kernel.
  99.  */
  100. #ifdef KERNEL
  101. #include "user/sys.h"
  102. #define FakePanicVoid(errstring)    \
  103.     Sys_Panic(SYS_WARNING, errstring);    \
  104.     return;
  105. #define    FakePanicValue(errstring)    \
  106.     Sys_Panic(SYS_WARNING, errstring);    \
  107.     return 0;
  108. #else /* KERNEL */
  109. #define FakePanicVoid(errstring)    \
  110.     panic(errstring);
  111. #define FakePanicValue(errstring)    \
  112.     panic(errstring);
  113. #endif /* KERNEL */
  114.  
  115. extern    long    strtol();
  116. extern    void    panic();
  117.  
  118. /*
  119.  * Forward declarations of procedures defined in this file.
  120.  */
  121. static  int     GetByte();
  122. static  int     GetHalfWord();
  123. static  int     GetWord();
  124. static  int     GetDoubleWord();
  125. static  void    CalcPutByteSize();
  126. static  void    CalcPutHalfWordSize();
  127. static  void    CalcPutWordSize();
  128. static  void    CalcPutDoubleSize();
  129. static  int     PutByte();
  130. static  int     PutHalfWord();
  131. static  int     PutWord();
  132. static  int     PutDoubleWord();
  133. static  int    CalcSize();
  134. static  int     CopyData();
  135.  
  136.  
  137.  
  138. /*
  139.  *----------------------------------------------------------------------
  140.  *
  141.  * Swap_Buffer -- 
  142.  *
  143.  *    Byte-swap incoming buffers from inType byte-order and alignment
  144.  *    to outType byte-order and alignment.
  145.  *
  146.  * Results:
  147.  *    None.
  148.  *
  149.  * Side effects:
  150.  *    The data is copied from the inBuf to the outBuf,
  151.  *    with byte-swapping or padding done as necessary.  *outSizePtr comes
  152.  *    in with the size in bytes of the outBuf passed in.  As we return,
  153.  *    *outSizePtr contains the actual size of swapped data.  If the number
  154.  *    is larger than when it came in, then there wasn't enough space in
  155.  *    outBuf, but we return how much space there should have been to
  156.  *    swap the data correctly, so the calling routine could reallocate
  157.  *    a larger buffer.   If *outSizePtr returns as 0, then something
  158.  *    else went wrong, such as the format string contained garbage or
  159.  *    contained a '*' that was not the last character, or the inBuf was
  160.  *    too short for the format string, or some such other error.  A
  161.  *    panic() in a user process or a Sys_Panic(SYS_WARNING, xxx) in the
  162.  *    kernel will describe the error.
  163.  *
  164.  *----------------------------------------------------------------------
  165.  */
  166. void
  167. Swap_Buffer(inBuf, inSize, inType, outType, format, outBuf, outSizePtr)
  168.     char    *inBuf;        /* in-coming buffer with data to swap */
  169.     int        inSize;        /* in BYTES - size of in-coming data */
  170.     int        inType;        /* byte-order/padding of in-coming buffer */
  171.     int        outType;    /* byte-order/padding of out-going buffer */
  172.     char    *format;    /* format string of in-coming data */
  173.     char    *outBuf;    /* where to put byte-swapped data */
  174.     int        *outSizePtr;    /* in-out param: size of outBuf passed in,
  175.                  * we calculate actual size of swapped data,
  176.                  * in BYTES and return that.  See procedure
  177.                  * comment for more details.
  178.                  */
  179. {
  180.     char    *inPtr;
  181.     char    *outPtr;
  182.     char    *formatPtr;
  183.     char    byteBuf[1];
  184.     char    halfWordBuf[2];
  185.     char    wordBuf[4];
  186.     char    doubleBuf[8];
  187.     int        outSize;
  188.     int        okayP = 1;
  189.     char    *cPtr;
  190.  
  191.  
  192. #ifdef NOTDEF
  193.     if (((unsigned int) inBuf) % 4  != 0) {
  194.     *outSizePtr = 0;
  195.     FakePanicVoid("Swap_Buffer: incoming buffer not long-word aligned.\n");
  196.     }
  197. #endif NOTDEF
  198.  
  199.     /*
  200.      * '*' can only be the last character in a format string.
  201.      */
  202.     cPtr = strchr(format, '*');
  203.     if (cPtr != NULL && cPtr != &(format[strlen(format) - 1])) {
  204.     *outSizePtr = 0;
  205.     FakePanicVoid("Swap_Buffer: the format string can contain a '*' only in the last character.\n");
  206.     }
  207.  
  208.     formatPtr = format;
  209.     inPtr = inBuf;
  210.     outPtr = outBuf;
  211.     outSize = *outSizePtr;
  212.  
  213. #ifdef NOTDEF
  214.     if (((unsigned int) outBuf) % 4  != 0) {
  215.     *outSizePtr = 0;
  216.     FakePanicVoid("Swap_Buffer: outgoing buffer not long-word aligned.\n");
  217.     }
  218. #endif NOTDEF
  219.  
  220.     /*
  221.      * while there's still more in inbuf, and we haven't finished with
  222.      * the format string...
  223.      */
  224.     while (*formatPtr != '\0' && okayP) {
  225.     switch (*formatPtr) {
  226.     case 'b':
  227.         /* increments inPtr and outPtr and formatPtr */
  228.         okayP = CopyData(inType, &inPtr, inSize, inBuf, byteBuf, outType,
  229.             &outPtr, outSize, outBuf, &formatPtr, GetByte, PutByte);
  230.         break;
  231.     case 'h':
  232.         okayP = CopyData(inType, &inPtr, inSize, inBuf, halfWordBuf,
  233.             outType, &outPtr, outSize, outBuf, &formatPtr, GetHalfWord,
  234.             PutHalfWord);
  235.         break;
  236.     case 'w':
  237.         okayP = CopyData(inType, &inPtr, inSize, inBuf, wordBuf, outType,
  238.             &outPtr, outSize, outBuf, &formatPtr, GetWord, PutWord);
  239.         break;
  240.     case 'd':
  241.         okayP = CopyData(inType, &inPtr, inSize, inBuf, doubleBuf, outType,
  242.             &outPtr, outSize, outBuf, &formatPtr, GetDoubleWord,
  243.             PutDoubleWord);
  244.         break;
  245.     default:
  246.         *outSizePtr = 0;
  247.         FakePanicVoid(
  248.             "Swap_Buffer: unrecognized character in format string.\n");
  249.     }
  250.     }
  251.  
  252.     *outSizePtr = (unsigned int) outPtr - (unsigned int) outBuf;
  253.     /*
  254.      * Time for error checking now, in the following order.
  255.      * 1) Check to see if we ran off of outBuf, if so, return the necessary
  256.      *        size of outBuf in order to swap correctly.
  257.      * 2) Check to see if we're not at the end of the format string.  If we
  258.      *        are not, then we ran off the end of inBuf (or ourBuf, but
  259.      *        we checked that in #1) and we panic (saying inBuf too short).
  260.      * 3) Check to see if we didn't finish inBuf.  If so, then we ran off the
  261.      *        end of the format string (or outBuf, but we checked than in
  262.      *        #1) and we panic (saying format string not long enough).
  263.      * 4) There's no need to check to see if we didn't finish outBuf.
  264.      *        If we didn't, then either we ran off the end of inBuf
  265.      *        or we ran off the end of the format string, or both.
  266.      *        If we ran off the end of inBuf, but not format,
  267.      *        then we checked this in #2.  If we ran off the end
  268.      *        of format, but not inBuf, then we checked this in #3.
  269.      *        So we must have run off the end of both - and this is okay,
  270.      *        since it just means that they gave us an output buffer that
  271.      *        was too large, so return no error!  Just keep the actual
  272.      *        size of the output data in the *outSizePtr.
  273.      */
  274.  
  275.     /* #1 Did we run off the end of outBuf? */
  276.     if (*outSizePtr > outSize) {
  277.     /* return necessary size of output buffer */
  278.     (void) Swap_BufSize(inBuf, inSize, inType, outType, format, outSizePtr);
  279.     return;
  280.     }
  281.     /* #2 Did we not finish format? */
  282.     if (*formatPtr != '\0') {
  283.     *outSizePtr = 0;
  284.     FakePanicVoid("Swap_Buffer: ran out of input data before reaching the end of the format string.\n");
  285.     }
  286.     if (((unsigned int) inPtr - (unsigned int) inBuf) < inSize) {
  287.     *outSizePtr = 0;
  288.     FakePanicVoid("Swap_Buffer: format string was not long enough to account for the size of the input data.\n");
  289.     }
  290.  
  291.     return;
  292. }
  293.  
  294.  
  295. /*
  296.  *----------------------------------------------------------------------
  297.  *
  298.  * Swap_BufSize -- 
  299.  *
  300.  *    Calculate the necessary size of an output buffer to swap the incoming
  301.  *    data into.  This takes care of padding on the different machines
  302.  *    that would affect the size of the swapped data.
  303.  *
  304.  * Results:
  305.  *    None.
  306.  *
  307.  * Side effects:
  308.  *    *outSizePtr is set to the size necessary to hold the byte-swapped
  309.  *    input data.  This takes into account differences of padding on
  310.  *    the different machines.  If the output size can't be correctly
  311.  *    calculated, then *outSizePtr returns a 0.  This can happen if
  312.  *    something went wrong, such as the format string contained garbage or
  313.  *    contained a '*' that was not the last character, or the inBuf was
  314.  *    too short for the format string, or some such other error.  Note that
  315.  *    less error checking is done in this routine than in Swap_Buffer(), since
  316.  *    the size of the inBuf relative to the format string isn't checked
  317.  *    unless it's crucial to calculating *outSizePtr.  (This occurs if the
  318.  *    format string contains a '*'.)     If such an error occurs,
  319.  *    panic() in a user process or a Sys_Panic(SYS_WARNING, xxx) in the
  320.  *    kernel will describe the error.
  321.  *
  322.  *----------------------------------------------------------------------
  323.  */
  324. void
  325. Swap_BufSize(inBuf, inSize, inType, outType, format, outSizePtr)
  326.     char    *inBuf;        /* in-coming buffer with data to swap */
  327.     int        inSize;        /* in BYTES - size of in-coming data */
  328.     int        inType;        /* byte-order/padding of in-coming buffer */
  329.     int        outType;    /* byte-order/padding of out-going buffer */
  330.     char    *format;    /* format string of in-coming data */
  331.     int        *outSizePtr;    /* We calculate the necessary size of swapped
  332.                  * data, in BYTES and return that.
  333.                  */
  334. {
  335.     char    *inPtr;
  336.     int        okayP = 1;
  337.     char    *formatPtr;
  338.     char    *cPtr;
  339.  
  340.     /*
  341.      * '*' can only be the last character in a format string.
  342.      */
  343.     cPtr = strchr(format, '*');
  344.     if (cPtr != NULL && cPtr != &(format[strlen(format) - 1])) {
  345.     *outSizePtr = 0;
  346.     FakePanicVoid("Swap_BufSize: the format string can contain a '*' only in the last character.\n");
  347.     }
  348.  
  349.     inPtr = inBuf;
  350.     formatPtr = format;
  351.     *outSizePtr = 0;
  352.  
  353.     while (*formatPtr != '\0' && okayP) {
  354.     switch (*formatPtr) {
  355.     case 'b':
  356.         /*
  357.          * Increments inPtr, outSize and formatPtr
  358.          */
  359.         okayP = CalcSize(inType, &inPtr, inSize, inBuf, outType, outSizePtr,
  360.             &formatPtr, GetByte, CalcPutByteSize);
  361.         break;
  362.     case 'h':
  363.         okayP = CalcSize(inType, &inPtr, inSize, inBuf, outType, outSizePtr,
  364.             &formatPtr, GetHalfWord, CalcPutHalfWordSize);
  365.         break;
  366.     case 'w':
  367.         okayP = CalcSize(inType, &inPtr, inSize, inBuf, outType, outSizePtr,
  368.             &formatPtr, GetWord, CalcPutWordSize);
  369.         break;
  370.     case 'd':
  371.         okayP = CalcSize(inType, &inPtr, inSize, inBuf, outType, outSizePtr,
  372.             &formatPtr, GetDoubleWord, CalcPutDoubleSize);
  373.         break;
  374.     default:
  375.         /* I should say what character it is... */
  376.         *outSizePtr = 0;
  377.         FakePanicVoid("Swap_BufSize: unrecognized character in format string.\n");
  378.     }
  379.     }
  380.     if (!okayP) {
  381.     *outSizePtr = 0;
  382.     FakePanicVoid("Swap_BufSize: the size of the format string and inBuf were not compatible.\n");
  383.     }
  384.     return;
  385. }
  386.  
  387.  
  388. /*
  389.  *----------------------------------------------------------------------
  390.  *
  391.  * CalcSize -- 
  392.  *
  393.  *    Calculate needed size for output byte-swapped buffer.
  394.  *
  395.  * Results:
  396.  *    True (1) if everything went okay and we were able to calculate
  397.  *    the output buffer size.  False (0) if we weren't able to calculate
  398.  *    it.  This occurs when the format string contains a '*' and we run
  399.  *    out of the in-coming buffer space before we even get to the '*', or
  400.  *    when the format string contains garbage.
  401.  *
  402.  * Side effects:
  403.  *    *outSizePtr gets filled in with the needed size of the output buffer.
  404.  *
  405.  *----------------------------------------------------------------------
  406.  */
  407. static int
  408. CalcSize(inType, inPtrPtr, inSize, inBuf, outType, outSizePtr, formatPtrPtr,
  409.                                 GetFunc, SizeFunc)
  410.     int        inType;
  411.     char    **inPtrPtr;
  412.     int        inSize;
  413.     char    *inBuf;
  414.     int        outType;
  415.     int        *outSizePtr;
  416.     char    **formatPtrPtr;
  417.     int        (*GetFunc)();
  418.     void    (*SizeFunc)();
  419. {
  420.     int        repCount;
  421.     int        an_int;
  422.     char    *inPtr;
  423.     char    *formatPtr;
  424.     int        okayP = 1;
  425.     int        checkInSizeP = 0;
  426.     int        inSizeLeft;
  427.  
  428.     inPtr = *inPtrPtr;
  429.     formatPtr = *formatPtrPtr;
  430.  
  431.     /*
  432.      * We need to check the size remaining in the inBuf only if there's
  433.      * a '*' in the format string.   This is because we cannot calculate
  434.      * the outSize correctly if there's a '*' except by seeing how much
  435.      * data there really is in the inBuf.
  436.      */
  437.     if (strchr(formatPtr, '*') != NULL) {
  438.     checkInSizeP = 1;
  439.     }
  440.     formatPtr++;
  441.     repCount = 0;
  442.     while (*formatPtr != '\0' && isdigit(*formatPtr)) {
  443.     char    *testStr;
  444.     repCount *= 10;
  445.     an_int = strtol(formatPtr, &testStr, 10);
  446.     if (testStr == formatPtr) {
  447.         FakePanicValue("Bad format string.\n");
  448.     }
  449.     repCount += an_int;
  450.     formatPtr++;
  451.     }
  452.     /*
  453.      * If there were no digits following the type character, then set repCount
  454.      * to 1 so that we do 1 character.
  455.      */
  456.     if (repCount == 0) {
  457.     repCount = 1;
  458.     }
  459.     if (*formatPtr == '*') {
  460.     formatPtr++;
  461.     /*
  462.      * Infinity, since we count down until zero.
  463.      */
  464.     repCount = -1;
  465.     }
  466.  
  467.     while (repCount != 0 && (((unsigned int) inPtr) -
  468.         ((unsigned int) inBuf)) < inSize) {
  469.     /* increments inPtr */
  470.     if (checkInSizeP) {
  471.         inSizeLeft = inSize - ((unsigned int) inPtr - (unsigned int) inBuf);
  472.         okayP = (*GetFunc)(inType, &inPtr, NULL, inSizeLeft);
  473.         if (!okayP) {
  474.         return 0;
  475.         }
  476.     }
  477.     /* increments outSize */
  478.     (*SizeFunc)(outType, outSizePtr);
  479.     repCount--;
  480.     }
  481.     *inPtrPtr = inPtr;
  482.     *formatPtrPtr = formatPtr;
  483.     return 1;
  484. }
  485.  
  486.  
  487. /*
  488.  *----------------------------------------------------------------------
  489.  *
  490.  * CopyData -- 
  491.  *
  492.  *    Byte-swap and copy a piece of data.
  493.  *
  494.  * Results:
  495.  *    None.
  496.  *
  497.  * Side effects:
  498.  *    The data is copied from the inBuf to the outBuf using given
  499.  *    retrieval and copy functions.
  500.  *
  501.  *----------------------------------------------------------------------
  502.  */
  503. static int
  504. CopyData(inType, inPtrPtr, inSize, inBuf, buf, outType, outPtrPtr,
  505.                         outSize, outBuf, formatPtrPtr,
  506.                         GetFunc, PutFunc)
  507.     int        inType;
  508.     char    **inPtrPtr;
  509.     int        inSize;
  510.     char    *inBuf;
  511.     char    *buf;
  512.     int        outType;
  513.     char    **outPtrPtr;
  514.     int        outSize;
  515.     char    *outBuf;
  516.     char    **formatPtrPtr;
  517.     int        (*GetFunc)();
  518.     int        (*PutFunc)();
  519. {
  520.     char    *inPtr;
  521.     char    *outPtr;
  522.     char    *formatPtr;
  523.     int        an_int;
  524.     int        repCount;
  525.     int        inSizeLeft;
  526.     int        outSizeLeft;
  527.     int        okayP = 1;
  528.  
  529.     inPtr = *inPtrPtr;
  530.     outPtr = *outPtrPtr;
  531.     formatPtr = *formatPtrPtr;
  532.  
  533.     formatPtr++;
  534.     repCount = 0;
  535.     while (*formatPtr != '\0' && isdigit(*formatPtr)) {
  536.     char    *testStr;
  537.     repCount *= 10;
  538.     an_int = strtol(formatPtr, &testStr, 10);
  539.     if (testStr == formatPtr) {
  540.         FakePanicValue("Ioctl format string bad.\n");
  541.     }
  542.     repCount += an_int;
  543.     formatPtr++;
  544.     }
  545.     /*
  546.      * If there were no digits following the type character, then set repCount
  547.      * to 1 so that we do 1 character.
  548.      */
  549.     if (repCount == 0) {
  550.     repCount = 1;
  551.     }
  552.     if (*formatPtr != '\0' && *formatPtr == '*') {
  553.     formatPtr++;
  554.     /*
  555.      * Infinity, since we count down until zero.
  556.      */
  557.     repCount = -1;
  558.     }
  559.     while (repCount != 0 && okayP) {
  560.     inSizeLeft = inSize - ((unsigned int) inPtr - (unsigned int) inBuf);
  561.     outSizeLeft = outSize - ((unsigned int) outPtr - (unsigned int) outBuf);
  562.     /* increments inPtr */
  563.     okayP = (*GetFunc)(inType, &inPtr, buf, inSizeLeft);
  564.     /* increments outPtr */
  565.     if (okayP) {
  566.         okayP = (*PutFunc)(outType, &outPtr, buf, outSizeLeft);
  567.     }
  568.     repCount--;
  569.     }
  570.  
  571.     *inPtrPtr = inPtr;
  572.     *outPtrPtr = outPtr;
  573.     *formatPtrPtr = formatPtr;
  574.  
  575.     return okayP;
  576. }
  577.  
  578.  
  579. /*
  580.  *----------------------------------------------------------------------
  581.  *
  582.  * GetByte, GetHalfWord, GetWord, GetDoubleWord -- 
  583.  *
  584.  *    Using the given byte-alignment type, grab the next bytes in the buffer.
  585.  *    If the buf param isn't NULL, the grabbed bytes will be put into it.
  586.  *
  587.  *    In the case of halfwords, words, and doubles, some byte-swapping may
  588.  *    be necessary.  If the inType of the buffer is of a different
  589.  *    alignment, some skipping of byte padding may be necessary before
  590.  *    grabbing the desired bytes.
  591.  *
  592.  *    Regardless, buf will be filled with bytes in the following order,
  593.  *    with no padding:
  594.  *        byte:    buf[0] is the byte.
  595.  *        halfword:    buf[0] is low byte, buf[1] is high byte.
  596.  *        word:    buf[0] is low byte, ..., buf[3] is high byte.
  597.  *        double:    buf[0] is low byte, ..., buf[7] is high byte.
  598.  *
  599.  * Results:
  600.  *    True (1) if everyting goes okay, and false (0) if there isn't enough
  601.  *    space left in inBuf.
  602.  *
  603.  * Side effects:
  604.  *    The byte grabbed is put into buf, if it isn't NULL.  The ptr into
  605.  *    the input buffer is incremented.  Even if there wasn't enough buffer
  606.  *    space, the routine increments the ptrs to where they would be if there
  607.  *    had been, so the calling routine can see what should have happened.
  608.  *
  609.  *----------------------------------------------------------------------
  610.  */
  611. /*ARGSUSED*/
  612. static int
  613. GetByte(inType, inPtrPtr, buf, inSizeLeft)
  614.     int        inType;
  615.     char    **inPtrPtr;
  616.     char    *buf;
  617.     int        inSizeLeft;
  618. {
  619.     if (buf != NULL && inSizeLeft >= 1) {
  620.     buf[0] = **inPtrPtr;
  621.     }
  622.     (*inPtrPtr)++;
  623.  
  624.     return (inSizeLeft >= 1);
  625. }
  626.  
  627. static int
  628. GetHalfWord(inType, inPtrPtr, buf, inSizeLeft)
  629.     int        inType;
  630.     char    **inPtrPtr;
  631.     char    *buf;
  632.     int        inSizeLeft;
  633. {
  634.     if (inType == SWAP_SUN_TYPE || inType == SWAP_SPARC_TYPE) {
  635.     /* one-byte padding if necessary */
  636.     if ((((unsigned int) *inPtrPtr) % 2) != 0) {
  637.         if (buf != NULL && inSizeLeft >= 3) {
  638.         buf[0] = *((*inPtrPtr) + 1);
  639.         buf[1] = *((*inPtrPtr) + 2);
  640.         }
  641.         *inPtrPtr += 3;
  642.         return (inSizeLeft >= 3);
  643.     } else {
  644.         if (buf != NULL && inSizeLeft >= 2) {
  645.         buf[0] = **inPtrPtr;
  646.         buf[1] = *((*inPtrPtr) + 1);
  647.         }
  648.         *inPtrPtr += 2;
  649.         return (inSizeLeft >= 2);
  650.     }
  651.     } else if (inType == SWAP_VAX_TYPE || inType == SWAP_SPUR_TYPE) {
  652.     /* one-byte padding if necessary */
  653.     if ((((unsigned int) *inPtrPtr) % 2) != 0) {
  654.         if (buf != NULL && inSizeLeft >= 3) {
  655.         buf[0] = *((*inPtrPtr) + 2);
  656.         buf[1] = *((*inPtrPtr) + 1);
  657.         }
  658.         *inPtrPtr += 3;
  659.         return (inSizeLeft >= 3);
  660.     } else {
  661.         if (buf != NULL && inSizeLeft >= 2) {
  662.         buf[0] = *((*inPtrPtr) + 1);
  663.         buf[1] = **inPtrPtr;
  664.         }
  665.         *inPtrPtr += 2;
  666.         return (inSizeLeft >= 2);
  667.     }
  668.     }
  669.     /* for lint */
  670.     return 0;
  671. }
  672.  
  673. static int
  674. GetWord(inType, inPtrPtr, buf, inSizeLeft)
  675.     int        inType;
  676.     char    **inPtrPtr;
  677.     char    *buf;
  678.     int        inSizeLeft;
  679. {
  680.     int        fix_it;
  681.  
  682.     if (inType == SWAP_SUN_TYPE) {
  683.     /* one-byte padding if necessary */
  684.     fix_it = (2 - (((unsigned int) *inPtrPtr) % 2)) % 2;
  685.     if (buf != NULL && inSizeLeft >= 4 + fix_it) {
  686.         buf[0] = *((*inPtrPtr) + fix_it);
  687.         buf[1] = *((*inPtrPtr) + fix_it + 1);
  688.         buf[2] = *((*inPtrPtr) + fix_it + 2);
  689.         buf[3] = *((*inPtrPtr) + fix_it + 3);
  690.     }
  691.     (*inPtrPtr) += 4 + fix_it;
  692.     return (inSizeLeft >= 4 + fix_it);
  693.     } else if (inType == SWAP_VAX_TYPE) {
  694.     fix_it = (2 - (((unsigned int) *inPtrPtr) % 2)) % 2;
  695.     if (buf != NULL && inSizeLeft >= 4 + fix_it) {
  696.         buf[0] = *((*inPtrPtr) + fix_it + 3);
  697.         buf[1] = *((*inPtrPtr) + fix_it + 2);
  698.         buf[2] = *((*inPtrPtr) + fix_it + 1);
  699.         buf[3] = *((*inPtrPtr) + fix_it);
  700.     }
  701.     (*inPtrPtr) += 4 + fix_it;
  702.     return (inSizeLeft >= 4 + fix_it);
  703.     } else if (inType == SWAP_SPUR_TYPE) {
  704.     fix_it = (4 - (((unsigned int) *inPtrPtr) % 4)) % 4;
  705.     if (buf != NULL && inSizeLeft >= 4 + fix_it) {
  706.         buf[0] = *(*inPtrPtr + fix_it + 3);
  707.         buf[1] = *(*inPtrPtr + fix_it + 2);
  708.         buf[2] = *(*inPtrPtr + fix_it + 1);
  709.         buf[3] = *(*inPtrPtr + fix_it);
  710.     }
  711.     (*inPtrPtr) += 4 + fix_it;
  712.     return (inSizeLeft >= 4 + fix_it);
  713.     } else if (inType == SWAP_SPARC_TYPE) {
  714.     fix_it = (4 - (((unsigned int) *inPtrPtr) % 4)) % 4;
  715.     if (buf != NULL && inSizeLeft >= 4 + fix_it) {
  716.         buf[0] = *(*inPtrPtr + fix_it);
  717.         buf[1] = *(*inPtrPtr + fix_it + 1);
  718.         buf[2] = *(*inPtrPtr + fix_it + 2);
  719.         buf[3] = *(*inPtrPtr + fix_it + 3);
  720.     }
  721.     (*inPtrPtr) += 4 + fix_it;
  722.     return (inSizeLeft >= 4 + fix_it);
  723.  
  724.     }
  725.     /* for lint */
  726.     return 0;
  727. }
  728.  
  729. /*ARGSUSED*/
  730. static int
  731. GetDoubleWord(inType, inPtrPtr, buf, inSizeLeft)
  732.     int        inType;
  733.     char    **inPtrPtr;
  734.     char    *buf;
  735.     int        inSizeLeft;
  736. {
  737.     /* what does this mean and where? */
  738.     FakePanicValue("GetDoubleWord:  don't know what a double means yet.\n");
  739. }
  740.  
  741.  
  742. /*
  743.  *----------------------------------------------------------------------
  744.  *
  745.  * CalcPutByteSize, CalcPutHalfWordSize, CalcPutWordSize, CalcPutDoubleSize -- 
  746.  *
  747.  *    Using the given byte-alignment type, figure out how much space is
  748.  *    required in the output buffer to add the next bytes.  This means
  749.  *    figuring out if padding is required on the machine type of the output
  750.  *    buffer.
  751.  *
  752.  *    We assume that outSizePtr is the current offset from the beginning
  753.  *    of a long-word aligned buffer.
  754.  *
  755.  * Results:
  756.  *    None.
  757.  *
  758.  * Side effects:
  759.  *    outSize is incremented to record the amount of space required.
  760.  *
  761.  *----------------------------------------------------------------------
  762.  */
  763. /*ARGSUSED*/
  764. static void
  765. CalcPutByteSize(outType, outSizePtr)
  766.     int        outType;
  767.     int        *outSizePtr;
  768. {
  769.     (*outSizePtr)++;
  770.     return;
  771. }
  772.  
  773. static void
  774. CalcPutHalfWordSize(outType, outSizePtr)
  775.     int        outType;
  776.     int        *outSizePtr;
  777. {
  778.     if (outType == SWAP_SUN_TYPE || outType == SWAP_VAX_TYPE ||
  779.         outType == SWAP_SPUR_TYPE || outType == SWAP_SPARC_TYPE) {
  780.     if ((((unsigned int) *outSizePtr) % 2) != 0) {
  781.         /* one byte padding to short-word align the thing */
  782.         (*outSizePtr) += 3;
  783.     } else {
  784.         (*outSizePtr) += 2;
  785.     }
  786.     }
  787.     return;
  788. }
  789.  
  790. static void
  791. CalcPutWordSize(outType, outSizePtr)
  792.     int        outType;
  793.     int        *outSizePtr;
  794. {
  795.     int        fix_it;
  796.  
  797.     if (outType == SWAP_SUN_TYPE || outType == SWAP_VAX_TYPE) {
  798.     if ((((unsigned int) *outSizePtr) % 2) != 0) {
  799.         /* one byte padding to short-word align the thing */
  800.         (*outSizePtr) += 5;
  801.     } else {
  802.         (*outSizePtr) += 4;
  803.     }
  804.     } else if (outType == SWAP_SPUR_TYPE || outType == SWAP_SPARC_TYPE) {
  805.     fix_it = (4 - (((unsigned int) *outSizePtr) % 4)) % 4;
  806.     /* byte padding to long-word align the thing */
  807.     (*outSizePtr) += 4 + fix_it;
  808.     }
  809.     return;
  810. }
  811.  
  812. /*ARGSUSED*/
  813. static void
  814. CalcPutDoubleSize(outType, outSizePtr)
  815.     int        outType;
  816.     int        *outSizePtr;
  817. {
  818.     FakePanicVoid("CalcPutDoubleSize: Don't know what this means yet.\n");
  819. }
  820.  
  821.  
  822. /*
  823.  *----------------------------------------------------------------------
  824.  *
  825.  * PutByte, PutHalfWord, PutWord, PutDoubleWord -- 
  826.  *
  827.  *    Using the given byte-alignment type, byte-swap and pad the data in
  828.  *    the buffer as necessary and copy it to the outBuf.
  829.  *
  830.  *    We assume that outSizePtr is the current offset from the beginning
  831.  *    of a long-word aligned buffer.
  832.  *
  833.  *    The data in buf is ordered with buf[0] as low byte and buf[n] as
  834.  *    high byte, with no padding.  So if the outType machine type requires
  835.  *    byte-swapping or padding from the current outPtr location, this is
  836.  *    done here.
  837.  *
  838.  * Results:
  839.  *    True (1) if everything goes okay, false (0) if there isn't enough
  840.  *    space left in outBuf.
  841.  *
  842.  * Side effects:
  843.  *    outSize is incremented to record the amount of space required.
  844.  *    outPtr is incremented to its new position.
  845.  *    Data is copied into outPtr's buffer.  Even if there wasn't enough buffer
  846.  *    space, the routine increments the ptrs to where they would be if there
  847.  *    had been, so the calling routine can see what should have happened.
  848.  *
  849.  *----------------------------------------------------------------------
  850.  */
  851. /*ARGSUSED*/
  852. static int
  853. PutByte(outType, outPtrPtr, buf, outSizeLeft)
  854.     int        outType;
  855.     char    **outPtrPtr;
  856.     char    *buf;
  857.     int        outSizeLeft;
  858. {
  859.     if (outSizeLeft >= 1) {
  860.     **outPtrPtr = buf[0];
  861.     }
  862.     (*outPtrPtr)++;
  863.     return (outSizeLeft >= 1);
  864.  
  865. }
  866.  
  867. static int
  868. PutHalfWord(outType, outPtrPtr, buf, outSizeLeft)
  869.     int        outType;
  870.     char    **outPtrPtr;
  871.     char    *buf;
  872.     int        outSizeLeft;
  873. {
  874.     if (outType == SWAP_SUN_TYPE || outType == SWAP_SPARC_TYPE) {
  875.     if ((((unsigned int) *outPtrPtr) % 2) != 0) {
  876.         if (outSizeLeft >= 3) {
  877.         **outPtrPtr = 0;
  878.         *(*outPtrPtr + 1) = buf[0];
  879.         *(*outPtrPtr + 2) = buf[1];
  880.         }
  881.         (*outPtrPtr) += 3;
  882.         return (outSizeLeft >= 3);
  883.     } else {
  884.         if (outSizeLeft >= 2) {
  885.         **outPtrPtr = buf[0];
  886.         *(*outPtrPtr + 1) = buf[1];
  887.         }
  888.         (*outPtrPtr) += 2;
  889.         return (outSizeLeft >= 2);
  890.     }
  891.     } else if (outType == SWAP_VAX_TYPE || outType == SWAP_SPUR_TYPE) {
  892.     if ((((unsigned int) *outPtrPtr) % 2) != 0) {
  893.         if (outSizeLeft >= 3) {
  894.         **outPtrPtr = 0;
  895.         *(*outPtrPtr + 1) = buf[1];
  896.         *(*outPtrPtr + 2) = buf[0];
  897.         }
  898.         (*outPtrPtr) += 3;
  899.         return (outSizeLeft >= 3);
  900.     } else {
  901.         if (outSizeLeft >= 2) {
  902.         **outPtrPtr = buf[1];
  903.         *(*outPtrPtr + 1) = buf[0];
  904.         }
  905.         (*outPtrPtr) += 2;
  906.         return (outSizeLeft >= 2);
  907.     }
  908.     }
  909.     /* for lint */
  910.     return 0;
  911. }
  912.  
  913. static int
  914. PutWord(outType, outPtrPtr, buf, outSizeLeft)
  915.     int        outType;
  916.     char    **outPtrPtr;
  917.     char    *buf;
  918.     int        outSizeLeft;
  919. {
  920.     int        fix_it;
  921.     int        i;
  922.  
  923.     if (outType == SWAP_SUN_TYPE) {
  924.     /* fix_it = 0 or 1 */
  925.     fix_it = (2 - (((unsigned int) *outPtrPtr) % 2)) % 2;
  926.     if (outSizeLeft >= 4 + fix_it) {
  927.         **outPtrPtr = 0;    /* Takes care of padding if fix_it = 1 */
  928.         *(*outPtrPtr + fix_it) = buf[0];
  929.         *(*outPtrPtr + fix_it + 1) = buf[1];
  930.         *(*outPtrPtr + fix_it + 2) = buf[2];
  931.         *(*outPtrPtr + fix_it + 3) = buf[3];
  932.     }
  933.     (*outPtrPtr) += 4 + fix_it;
  934.     return (outSizeLeft >= 4 + fix_it);
  935.     } else if (outType == SWAP_VAX_TYPE) {
  936.     /* fix_it = 0 or 1 */
  937.     fix_it = (2 - (((unsigned int) *outPtrPtr) % 2)) % 2;
  938.     if (outSizeLeft >= 4 + fix_it) {
  939.         **outPtrPtr = 0;    /* Takes care of padding if fix_it = 1 */
  940.         *(*outPtrPtr + fix_it) = buf[3];
  941.         *(*outPtrPtr + fix_it + 1) = buf[2];
  942.         *(*outPtrPtr + fix_it + 2) = buf[1];
  943.         *(*outPtrPtr + fix_it + 3) = buf[0];
  944.     }
  945.     (*outPtrPtr) += 4 + fix_it;
  946.     return (outSizeLeft >= 4 + fix_it);
  947.     } else if (outType == SWAP_SPUR_TYPE) {
  948.     fix_it = (4 - (((unsigned int) *outPtrPtr) % 4)) % 4;
  949.     /* padding */
  950.     if (outSizeLeft >= 4 + fix_it) {
  951.         for (i = 0; i < fix_it; i++) {
  952.         *(*outPtrPtr + i) = 0;
  953.         }
  954.         *(*outPtrPtr + fix_it) = buf[3];
  955.         *(*outPtrPtr + fix_it + 1) = buf[2];
  956.         *(*outPtrPtr + fix_it + 2) = buf[1];
  957.         *(*outPtrPtr + fix_it + 3) = buf[0];
  958.     }
  959.     (*outPtrPtr) += 4 + fix_it;
  960.     return (outSizeLeft >= 4 + fix_it);
  961.     } else if (outType == SWAP_SPARC_TYPE) {
  962.     fix_it = (4 - (((unsigned int) *outPtrPtr) % 4)) % 4;
  963.     /* padding */
  964.     if (outSizeLeft >= 4 + fix_it) {
  965.         for (i = 0; i < fix_it; i++) {
  966.         *(*outPtrPtr + i) = 0;
  967.         }
  968.         *(*outPtrPtr + fix_it) = buf[0];
  969.         *(*outPtrPtr + fix_it + 1) = buf[1];
  970.         *(*outPtrPtr + fix_it + 2) = buf[2];
  971.         *(*outPtrPtr + fix_it + 3) = buf[3];
  972.     }
  973.     (*outPtrPtr) += 4 + fix_it;
  974.     return (outSizeLeft >= 4 + fix_it);
  975.     }
  976.     /* for lint */
  977.     return 0;
  978. }
  979.  
  980. /*ARGSUSED*/
  981. static int
  982. PutDoubleWord(outType, outPtrPtr, buf, outSizeLeft)
  983.     int        outType;
  984.     char    **outPtrPtr;
  985.     char    *buf;
  986.     int        outSizeLeft;
  987. {
  988.     FakePanicValue("PutDoubleWord: Don't know what this means yet.\n");
  989. }
  990. @
  991.  
  992.  
  993. 1.8
  994. log
  995. @now does structures, unions. >>> THIS IS NOW OBSOLETE. USE FMT_CONVERT<<<
  996. @
  997. text
  998. @d23 1
  999. a23 1
  1000. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/swapBuffer.c,v 1.7 89/02/27 17:50:00 mgbaker Exp Locker: jhh $ SPRITE (Berkeley)";
  1001. d57 14
  1002. a70 14
  1003. extern  int     GetByte();
  1004. extern  int     GetHalfWord();
  1005. extern  int     GetWord();
  1006. extern  int     GetDoubleWord();
  1007. extern  void    CalcPutByteSize();
  1008. extern  void    CalcPutHalfWordSize();
  1009. extern  void    CalcPutWordSize();
  1010. extern  void    CalcPutDoubleSize();
  1011. extern  int     PutByte();
  1012. extern  int     PutHalfWord();
  1013. extern  int     PutWord();
  1014. extern  int     PutDoubleWord();
  1015. extern  int    CalcSize();
  1016. extern  int     CopyData();
  1017. @
  1018.  
  1019.  
  1020. 1.7
  1021. log
  1022. @Added sun4 SPARC support.
  1023. @
  1024. text
  1025. @d23 1
  1026. a23 1
  1027. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/swapBuffer.c,v 1.6 88/09/16 12:41:59 mlgray Exp Locker: mgbaker $ SPRITE (Berkeley)";
  1028. d592 1
  1029. a592 1
  1030.         buf[0] = *((*inPtrPtr) + 1);
  1031. @
  1032.  
  1033.  
  1034. 1.6
  1035. log
  1036. @changed calls to index to calls to strchr
  1037. @
  1038. text
  1039. @d23 1
  1040. a23 1
  1041. static char rcsid[] = "$Header: swapBuffer.c,v 1.5 88/09/14 16:46:25 mlgray Exp $ SPRITE (Berkeley)";
  1042. d570 1
  1043. a570 1
  1044.     if (inType == SWAP_SUN_TYPE) {
  1045. d587 1
  1046. a587 1
  1047.     } else if (inType == SWAP_VAX_TYPE) {
  1048. a603 17
  1049.     } else if (inType == SWAP_SPUR_TYPE) {
  1050.     /* one-byte padding if necessary */
  1051.     if ((((unsigned int) *inPtrPtr) % 2) != 0) {
  1052.         if (buf != NULL && inSizeLeft >= 3) {
  1053.         buf[0] = *((*inPtrPtr) + 2);
  1054.         buf[1] = *((*inPtrPtr) + 1);
  1055.         }
  1056.         *inPtrPtr += 3;
  1057.         return (inSizeLeft >= 3);
  1058.     } else {
  1059.         if (buf != NULL && inSizeLeft >= 2) {
  1060.         buf[0] = *((*inPtrPtr) + 1);
  1061.         buf[1] = **inPtrPtr;
  1062.         }
  1063.         *inPtrPtr += 2;
  1064.         return (inSizeLeft >= 2);
  1065.     }
  1066. d649 11
  1067. d714 2
  1068. a715 1
  1069.     if (outType == SWAP_SUN_TYPE) {
  1070. a721 14
  1071.     } else if (outType == SWAP_VAX_TYPE) {
  1072.     if ((((unsigned int) *outSizePtr) % 2) != 0) {
  1073.         /* one byte padding to short-word align the thing */
  1074.         (*outSizePtr) += 3;
  1075.     } else {
  1076.         (*outSizePtr) += 2;
  1077.     }
  1078.     } else if (outType == SWAP_SPUR_TYPE) {
  1079.     if ((((unsigned int) *outSizePtr) % 2) != 0) {
  1080.         /* one byte padding to short-word align the thing */
  1081.         (*outSizePtr) += 3;
  1082.     } else {
  1083.         (*outSizePtr) += 2;
  1084.     }
  1085. d733 1
  1086. a733 1
  1087.     if (outType == SWAP_SUN_TYPE) {
  1088. d740 1
  1089. a740 8
  1090.     } else if (outType == SWAP_VAX_TYPE) {
  1091.     if ((((unsigned int) *outSizePtr) % 2) != 0) {
  1092.         /* one byte padding to short-word align the thing */
  1093.         (*outSizePtr) += 5;
  1094.     } else {
  1095.         (*outSizePtr) += 4;
  1096.     }
  1097.     } else if (outType == SWAP_SPUR_TYPE) {
  1098. d810 1
  1099. a810 1
  1100.     if (outType == SWAP_SUN_TYPE) {
  1101. d827 1
  1102. a827 1
  1103.     } else if (outType == SWAP_VAX_TYPE) {
  1104. a843 19
  1105.     } else if (outType == SWAP_SPUR_TYPE) {
  1106.     if ((((unsigned int) *outPtrPtr) % 2) != 0) {
  1107.         /* Correct padding? */
  1108.         if (outSizeLeft >= 3) {
  1109.         **outPtrPtr = 0;
  1110.         *(*outPtrPtr + 1) = buf[1];
  1111.         *(*outPtrPtr + 2) = buf[0];
  1112.         /* one-byte padding to short-word align the thing */
  1113.         }
  1114.         *outPtrPtr += 3;
  1115.         return (outSizeLeft >= 3);
  1116.     } else {
  1117.         if (outSizeLeft >= 2) {
  1118.         **outPtrPtr = buf[1];
  1119.         *(*outPtrPtr + 1) = buf[0];
  1120.         }
  1121.         *outPtrPtr += 2;
  1122.         return (outSizeLeft >= 2);
  1123.     }
  1124. d894 14
  1125. @
  1126.  
  1127.  
  1128. 1.5
  1129. log
  1130. @Added extra panic statements.
  1131. @
  1132. text
  1133. @d23 1
  1134. a23 1
  1135. static char rcsid[] = "$Header: swapBuffer.c,v 1.4 88/09/14 12:22:20 mlgray Exp $ SPRITE (Berkeley)";
  1136. a52 1
  1137. extern    char    *index();
  1138. d138 1
  1139. a138 1
  1140.     cPtr = index(format, '*');
  1141. d279 1
  1142. a279 1
  1143.     cPtr = index(format, '*');
  1144. d373 1
  1145. a373 1
  1146.     if (index(formatPtr, '*') != NULL) {
  1147. @
  1148.  
  1149.  
  1150. 1.4
  1151. log
  1152. @lint errors removed
  1153. @
  1154. text
  1155. @d23 1
  1156. a23 1
  1157. static char rcsid[] = "$Header: swapBuffer.c,v 1.3 88/09/13 19:37:15 mlgray Exp $ SPRITE (Berkeley)";
  1158. d37 1
  1159. d39 1
  1160. d42 1
  1161. d96 4
  1162. a99 1
  1163.  *    contained a '*' that was not the last character.
  1164. d141 1
  1165. d190 21
  1166. d212 2
  1167. a213 2
  1168.     /* Did we run short on the output buffer? */
  1169.     if (((unsigned int) outPtr) - ((unsigned int) outBuf) > outSize) {
  1170. a215 1
  1171.  
  1172. d218 9
  1173. a226 9
  1174.     /*
  1175.      * If we ran short on the input buffer, we just return, hoping that
  1176.      * *outSizePtr is not what the caller expects, thus warning him of
  1177.      * trouble.  This isn't the safest mechanism (what if the in param
  1178.      * of *outSizePtr was also wrong so that coincidentally what we
  1179.      * return makes things look okay?), but it seems to be what Brent
  1180.      * would like...  Same thing if we run short on formatString or don't
  1181.      * finish with it.
  1182.      */
  1183. d248 10
  1184. a257 3
  1185.  *    calculated (because the format string contains a '*' and the
  1186.  *    inBuf runs out of data before we even get to that '*' or because
  1187.  *    the format string contains garbage), then *outSizePtr is set to 0;
  1188. d282 1
  1189. d313 1
  1190. d319 1
  1191. d512 1
  1192. a512 1
  1193.     return 1;
  1194. @
  1195.  
  1196.  
  1197. 1.3
  1198. log
  1199. @Made integer repititions of values in format string conform to the
  1200. manual page!
  1201. @
  1202. text
  1203. @d1 1
  1204. a1 1
  1205. /* 
  1206. d23 1
  1207. a23 1
  1208. static char rcsid[] = "$Header: proto.c,v 1.2 88/03/11 08:39:08 ouster Exp $ SPRITE (Berkeley)";
  1209. d29 1
  1210. d37 1
  1211. a37 1
  1212. #define FakePanic(errstring)    \
  1213. d39 2
  1214. d42 1
  1215. a42 1
  1216. #define FakePanic(errstring)    \
  1217. d44 2
  1218. d48 4
  1219. d126 1
  1220. a126 1
  1221.     FakePanic("Swap_Buffer: incoming buffer not long-word aligned.\n");
  1222. d133 3
  1223. a135 4
  1224.     if ((cPtr = (char *) index(format, '*')) != NULL) {
  1225.     if (cPtr != &(format[strlen(format) - 1])) {
  1226.         FakePanic("Swap_Buffer: the format string can contain a '*' only in the last character.\n");
  1227.     }
  1228. d146 1
  1229. a146 1
  1230.     FakePanic("Swap_Buffer: outgoing buffer not long-word aligned.\n");
  1231. d177 1
  1232. a177 1
  1233.         FakePanic(
  1234. d246 3
  1235. a248 4
  1236.     if ((cPtr = (char *) index(format, '*')) != NULL) {
  1237.     if (cPtr != &(format[strlen(format) - 1])) {
  1238.         FakePanic("Swap_Buffer: the format string can contain a '*' only in the last character.\n");
  1239.     }
  1240. d278 1
  1241. a278 1
  1242.         FakePanic("Swap_Buffer: unrecognized character in format string.\n");
  1243. d347 1
  1244. a347 2
  1245.         FakePanic("Bad format string.\n");
  1246.         return 0;
  1247. d440 1
  1248. a440 2
  1249.         FakePanic("Ioctl format string bad.\n");
  1250.         return 0;
  1251. d586 2
  1252. d631 2
  1253. d635 1
  1254. d644 1
  1255. a644 1
  1256.     FakePanic("GetDoubleWord:  don't know what a double means yet.\n");
  1257. d738 1
  1258. d744 1
  1259. a744 1
  1260.     FakePanic("CalcPutDoubleSize: Don't know what this means yet.\n");
  1261. d854 2
  1262. d896 1
  1263. a896 1
  1264.         for (i = 0; i++; i < fix_it) {
  1265. d907 2
  1266. d911 1
  1267. d919 1
  1268. a919 1
  1269.     FakePanic("PutDoubleWord: Don't know what this means yet.\n");
  1270. @
  1271.  
  1272.  
  1273. 1.2
  1274. log
  1275. @Took out long-word alignment checks and fixed a return value.
  1276. @
  1277. text
  1278. @d83 2
  1279. a84 1
  1280.  *    else went wrong, such as the format string contained garbage.
  1281. d111 1
  1282. d117 1
  1283. a117 1
  1284.     FakePanic("SwapIncoming: incoming buffer not long-word aligned.\n");
  1285. d121 9
  1286. a129 1
  1287.     /* reset vars */
  1288. d133 2
  1289. d138 1
  1290. a138 1
  1291.     FakePanic("SwapIncoming: outgoing buffer not long-word aligned.\n");
  1292. a141 1
  1293.     outSize = *outSizePtr;
  1294. d170 1
  1295. a170 1
  1296.             "SwapIncoming: unrecognized character in format string.\n");
  1297. d185 1
  1298. a185 1
  1299.      * *outSizePtr is not what the caller expects, thus warnng him of
  1300. d233 1
  1301. d236 1
  1302. a236 1
  1303.      * Calculate outBuf size
  1304. d238 6
  1305. d247 1
  1306. d271 1
  1307. a271 1
  1308.         FakePanic("SwapIncoming: unrecognized character in format string.\n");
  1309. d300 1
  1310. a300 1
  1311. int
  1312. d324 6
  1313. a329 1
  1314.     /* increments inPtr */
  1315. a331 5
  1316.     inSizeLeft = inSize - ((unsigned int) inPtr - (unsigned int) inBuf);
  1317.     okayP = (*GetFunc)(inType, &inPtr, NULL, inSizeLeft);
  1318.     if (!okayP) {
  1319.         return 0;
  1320.     }
  1321. a332 2
  1322.     /* increments outSize */
  1323.     (*SizeFunc)(outType, outSizePtr);
  1324. d346 8
  1325. a353 1
  1326.     if (*formatPtr != '\0' && *formatPtr == '*') {
  1327. d397 1
  1328. a397 1
  1329. int
  1330. a426 10
  1331.     inSizeLeft = inSize - ((unsigned int) inPtr - (unsigned int) inBuf);
  1332.     outSizeLeft = outSize - ((unsigned int) outPtr - (unsigned int) outBuf);
  1333.  
  1334.     /* increments inPtr */
  1335.     okayP = (*GetFunc)(inType, &inPtr, buf, inSizeLeft);
  1336.     /* increments outPtr */
  1337.     okayP = (*PutFunc)(outType, &outPtr, buf, outSizeLeft);
  1338.     if (!okayP) {
  1339.     return 0;
  1340.     }
  1341. d440 7
  1342. d460 3
  1343. a462 1
  1344.     okayP = (*PutFunc)(outType, &outPtr, buf, outSizeLeft);
  1345. d507 1
  1346. a507 1
  1347. int
  1348. d522 1
  1349. a522 1
  1350. int
  1351. d583 1
  1352. a583 1
  1353. int
  1354. d626 1
  1355. a626 1
  1356. int
  1357. d660 1
  1358. a660 1
  1359. void
  1360. d669 1
  1361. a669 1
  1362. void
  1363. d699 1
  1364. a699 1
  1365. void
  1366. d728 1
  1367. a728 1
  1368. void
  1369. d767 1
  1370. a767 1
  1371. int
  1372. d782 1
  1373. a782 1
  1374. int
  1375. d845 1
  1376. a845 1
  1377. int
  1378. d896 1
  1379. a896 1
  1380. int
  1381. @
  1382.  
  1383.  
  1384. 1.1
  1385. log
  1386. @Initial revision
  1387. @
  1388. text
  1389. @a27 1
  1390. #include "cvt.h"
  1391. d83 1
  1392. a83 2
  1393.  *    else went wrong, such as the input buffer or output buffer not
  1394.  *    being long-word aligned, or the format string containing garbage.
  1395. d112 1
  1396. d115 1
  1397. a115 1
  1398.     FakePanic("SwapIncoming: incoming buffer not long-word aligned.");
  1399. d117 1
  1400. d123 1
  1401. d126 1
  1402. a126 1
  1403.     FakePanic("SwapIncoming: outgoing buffer not long-word aligned.");
  1404. d128 1
  1405. d158 2
  1406. a159 1
  1407.         FakePanic("SwapIncoming: unrecognized character in format string.");
  1408. d252 1
  1409. a252 1
  1410.         FakePanic("SwapIncoming: unrecognized character in format string.");
  1411. d319 1
  1412. d321 3
  1413. a323 2
  1414.     if (Cvt_AtoI(formatPtr, 10, &an_int) == formatPtr) {
  1415.         FakePanic("Bad format string.");
  1416. d416 1
  1417. d418 3
  1418. a420 2
  1419.     if (Cvt_AtoI(formatPtr, 10, &an_int) == formatPtr) {
  1420.         FakePanic("Ioctl format string bad.");
  1421. d611 1
  1422. a611 1
  1423.     FakePanic("GetDoubleWord:  don't know what a double means yet.");
  1424. d710 1
  1425. a710 1
  1426.     FakePanic("CalcPutDoubleSize: Don't know what this means yet.");
  1427. d880 1
  1428. a880 1
  1429.     FakePanic("PutDoubleWord: Don't know what this means yet.");
  1430. @
  1431.